声明 模块 "dns" {
    // Supported getaddrinfo flags.

    //@@{ __地址配置__:ADDRCONFIG }
    常量 __地址配置__: 数字;

    //@@{ __V4映射__:V4MAPPED }
    常量 __V4映射__: 数字;

    //@@{ 查找选项_:LookupOptions }
    接口 查找选项_ {

        //@@{ 家族:family }
        家族?: 数字;

        //@@{ 提示:hints }
        提示?: 数字;

        //@@{ 全部:all }
        全部?: 真假;

        //@@{ 逐字逐句的:verbatim }
        逐字逐句的?: 真假;
    }

    //@@{ 查找一个选项_:LookupOneOptions, 查找选项_:LookupOptions }
    接口 查找一个选项_ 扩展 查找选项_ {

        //@@{ 全部:all }
        全部?: 为假;
    }

    //@@{ 查找所有选项_:LookupAllOptions, 查找选项_:LookupOptions }
    接口 查找所有选项_ 扩展 查找选项_ {

        //@@{ 全部:all }
        全部: 为真;
    }

    //@@{ 查找地址_:LookupAddress }
    接口 查找地址_ {

        //@@{ 地址:address }
        地址: 文字;

        //@@{ 家族:family }
        家族: 数字;
    }

    //@@{ 查找:lookup, 错误异常_:ErrnoException }
    函数 查找(主机名: 文字, 家族: 数字, 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字, 家族: 数字) => 无值): 无值;

    //@@{ 查找:lookup, 查找一个选项_:LookupOneOptions, 错误异常_:ErrnoException }
    函数 查找(主机名: 文字, 选项组: 查找一个选项_, 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字, 家族: 数字) => 无值): 无值;

    //@@{ 查找:lookup, 查找所有选项_:LookupAllOptions, 错误异常_:ErrnoException, 查找地址_:LookupAddress }
    函数 查找(主机名: 文字, 选项组: 查找所有选项_, 回调: (错: NodeJS.错误异常_ | 空值, 地址: 查找地址_[]) => 无值): 无值;

    //@@{ 查找:lookup, 查找选项_:LookupOptions, 错误异常_:ErrnoException, 查找地址_:LookupAddress }
    函数 查找(主机名: 文字, 选项组: 查找选项_, 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字 | 查找地址_[], 家族: 数字) => 无值): 无值;

    //@@{ 查找:lookup, 错误异常_:ErrnoException }
    函数 查找(主机名: 文字, 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字, 家族: 数字) => 无值): 无值;

    // NOTE: This namespace provides design-time support for util.promisify. Exported members do not exist at runtime.

    //@@{ 查找:lookup }
    名域 查找 {

        //@@{ __转为预设__:__promisify__, 查找所有选项_:LookupAllOptions, 预设_:Promise, 地址:address }
        //@@{ 查找地址_:LookupAddress }
        函数 __转为预设__(主机名: 文字, 选项组: 查找所有选项_): 预设_<{ 地址: 查找地址_[] }>;

        //@@{ __转为预设__:__promisify__, 查找一个选项_:LookupOneOptions, 预设_:Promise, 地址:address }
        //@@{ 家族:family }
        函数 __转为预设__(主机名: 文字, 选项组?: 查找一个选项_ | 数字): 预设_<{ 地址: 文字, 家族: 数字 }>;

        //@@{ __转为预设__:__promisify__, 查找选项_:LookupOptions, 预设_:Promise, 地址:address }
        //@@{ 查找地址_:LookupAddress, 家族:family }
        函数 __转为预设__(主机名: 文字, 选项组?: 查找选项_ | 数字): 预设_<{ 地址: 文字 | 查找地址_[], 家族?: 数字 }>;
    }

    //@@{ 查找服务:lookupService, 错误异常_:ErrnoException }
    函数 查找服务(地址: 文字, 端口: 数字, 回调: (错: NodeJS.错误异常_ | 空值, 主机名: 文字, 服务: 文字) => 无值): 无值;

    //@@{ 查找服务:lookupService }
    名域 查找服务 {

        //@@{ __转为预设__:__promisify__, 预设_:Promise, 主机名:hostname, 服务:service }
        函数 __转为预设__(地址: 文字, 端口: 数字): 预设_<{ 主机名: 文字, 服务: 文字 }>;
    }

    //@@{ 解析选项_:ResolveOptions }
    接口 解析选项_ {

        //@@{ 存活时间:ttl }
        存活时间: 真假;
    }

    //@@{ 解析与存活时间选项_:ResolveWithTtlOptions, 解析选项_:ResolveOptions }
    接口 解析与存活时间选项_ 扩展 解析选项_ {

        //@@{ 存活时间:ttl }
        存活时间: 为真;
    }

    //@@{ 记录与存活时间_:RecordWithTtl }
    接口 记录与存活时间_ {

        //@@{ 地址:address }
        地址: 文字;

        //@@{ 存活时间:ttl }
        存活时间: 数字;
    }

    /** @deprecated Use AnyARecord or AnyAaaaRecord instead. */

    //@@{ 任何记录包含Ttl_:AnyRecordWithTtl, 任何A记录_:AnyARecord, 任何Aaaa记录_:AnyAaaaRecord }
    类型 任何记录包含Ttl_ = 任何A记录_ | 任何Aaaa记录_;

    //@@{ 任何A记录_:AnyARecord, 记录与存活时间_:RecordWithTtl }
    接口 任何A记录_ 扩展 记录与存活时间_ {

        //@@{ 类型:type }
        类型: "A";
    }

    //@@{ 任何Aaaa记录_:AnyAaaaRecord, 记录与存活时间_:RecordWithTtl }
    接口 任何Aaaa记录_ 扩展 记录与存活时间_ {

        //@@{ 类型:type }
        类型: "AAAA";
    }

    //@@{ Mx记录_:MxRecord }
    接口 Mx记录_ {

        //@@{ 优先级:priority }
        优先级: 数字;

        //@@{ 交换:exchange }
        交换: 文字;
    }

    //@@{ 任何Mx记录_:AnyMxRecord, Mx记录_:MxRecord }
    接口 任何Mx记录_ 扩展 Mx记录_ {

        //@@{ 类型:type }
        类型: "MX";
    }

    //@@{ Naptr记录_:NaptrRecord }
    接口 Naptr记录_ {

        //@@{ 标志:flags }
        标志: 文字;

        //@@{ 服务:service }
        服务: 文字;

        //@@{ 正则表达式:regexp }
        正则表达式: 文字;

        //@@{ 更换:replacement }
        更换: 文字;

        //@@{ 顺序:order }
        顺序: 数字;

        //@@{ 偏好:preference }
        偏好: 数字;
    }

    //@@{ 任何Naptr记录_:AnyNaptrRecord, Naptr记录_:NaptrRecord }
    接口 任何Naptr记录_ 扩展 Naptr记录_ {

        //@@{ 类型:type }
        类型: "NAPTR";
    }

    //@@{ Soa记录_:SoaRecord }
    接口 Soa记录_ {

        //@@{ ns名称:nsname }
        ns名称: 文字;

        //@@{ 主机管理员:hostmaster }
        主机管理员: 文字;

        //@@{ 串行:serial }
        串行: 数字;

        //@@{ 刷新:refresh }
        刷新: 数字;

        //@@{ 重试:retry }
        重试: 数字;

        //@@{ 到期:expire }
        到期: 数字;

        //@@{ 最小生存时间:minttl }
        最小生存时间: 数字;
    }

    //@@{ 任何Soa记录_:AnySoaRecord, Soa记录_:SoaRecord }
    接口 任何Soa记录_ 扩展 Soa记录_ {

        //@@{ 类型:type }
        类型: "SOA";
    }

    //@@{ Srv记录_:SrvRecord }
    接口 Srv记录_ {

        //@@{ 优先级:priority }
        优先级: 数字;

        //@@{ 权重:weight }
        权重: 数字;

        //@@{ 端口:port }
        端口: 数字;

        //@@{ 名称:name }
        名称: 文字;
    }

    //@@{ 任何Srv记录_:AnySrvRecord, Srv记录_:SrvRecord }
    接口 任何Srv记录_ 扩展 Srv记录_ {

        //@@{ 类型:type }
        类型: "SRV";
    }

    //@@{ 任何Txt记录_:AnyTxtRecord }
    接口 任何Txt记录_ {

        //@@{ 类型:type }
        类型: "TXT";

        //@@{ 条目:entries }
        条目: 文字[];
    }

    //@@{ 任何Ns记录_:AnyNsRecord }
    接口 任何Ns记录_ {

        //@@{ 类型:type }
        类型: "NS";

        //@@{ 值:value }
        值: 文字;
    }

    //@@{ 任何PTR记录_:AnyPtrRecord }
    接口 任何PTR记录_ {

        //@@{ 类型:type }
        类型: "PTR";

        //@@{ 值:value }
        值: 文字;
    }

    //@@{ 任何C名称记录_:AnyCnameRecord }
    接口 任何C名称记录_ {

        //@@{ 类型:type, "__C名称__":"CNAME" }
        类型: "__C名称__";

        //@@{ 值:value }
        值: 文字;
    }

    //@@{ 任何记录_:AnyRecord, 任何A记录_:AnyARecord }
    类型 任何记录_ = 任何A记录_ |

        //@@{ 任何Aaaa记录_:AnyAaaaRecord }
        任何Aaaa记录_ |

        //@@{ 任何C名称记录_:AnyCnameRecord }
        任何C名称记录_ |

        //@@{ 任何Mx记录_:AnyMxRecord }
        任何Mx记录_ |

        //@@{ 任何Naptr记录_:AnyNaptrRecord }
        任何Naptr记录_ |

        //@@{ 任何Ns记录_:AnyNsRecord }
        任何Ns记录_ |

        //@@{ 任何PTR记录_:AnyPtrRecord }
        任何PTR记录_ |

        //@@{ 任何Soa记录_:AnySoaRecord }
        任何Soa记录_ |

        //@@{ 任何Srv记录_:AnySrvRecord }
        任何Srv记录_ |

        //@@{ 任何Txt记录_:AnyTxtRecord }
        任何Txt记录_;

    //@@{ 解决:resolve, 错误异常_:ErrnoException }
    函数 解决(主机名: 文字, 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字[]) => 无值): 无值;

    //@@{ 解决:resolve, 错误异常_:ErrnoException }
    函数 解决(主机名: 文字, 资源记录类型: "A", 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字[]) => 无值): 无值;

    //@@{ 解决:resolve, 错误异常_:ErrnoException }
    函数 解决(主机名: 文字, 资源记录类型: "AAAA", 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字[]) => 无值): 无值;

    //@@{ 解决:resolve, 错误异常_:ErrnoException, 任何记录_:AnyRecord }
    函数 解决(主机名: 文字, 资源记录类型: "ANY", 回调: (错: NodeJS.错误异常_ | 空值, 地址: 任何记录_[]) => 无值): 无值;

    //@@{ 解决:resolve, 错误异常_:ErrnoException, "__C名称__":"CNAME" }
    函数 解决(主机名: 文字, 资源记录类型: "__C名称__", 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字[]) => 无值): 无值;

    //@@{ 解决:resolve, 错误异常_:ErrnoException, Mx记录_:MxRecord }
    函数 解决(主机名: 文字, 资源记录类型: "MX", 回调: (错: NodeJS.错误异常_ | 空值, 地址: Mx记录_[]) => 无值): 无值;

    //@@{ 解决:resolve, 错误异常_:ErrnoException, Naptr记录_:NaptrRecord }
    函数 解决(主机名: 文字, 资源记录类型: "NAPTR", 回调: (错: NodeJS.错误异常_ | 空值, 地址: Naptr记录_[]) => 无值): 无值;

    //@@{ 解决:resolve, 错误异常_:ErrnoException }
    函数 解决(主机名: 文字, 资源记录类型: "NS", 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字[]) => 无值): 无值;

    //@@{ 解决:resolve, 错误异常_:ErrnoException }
    函数 解决(主机名: 文字, 资源记录类型: "PTR", 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字[]) => 无值): 无值;

    //@@{ 解决:resolve, 错误异常_:ErrnoException, Soa记录_:SoaRecord }
    函数 解决(主机名: 文字, 资源记录类型: "SOA", 回调: (错: NodeJS.错误异常_ | 空值, 地址: Soa记录_) => 无值): 无值;

    //@@{ 解决:resolve, 错误异常_:ErrnoException, Srv记录_:SrvRecord }
    函数 解决(主机名: 文字, 资源记录类型: "SRV", 回调: (错: NodeJS.错误异常_ | 空值, 地址: Srv记录_[]) => 无值): 无值;

    //@@{ 解决:resolve, 错误异常_:ErrnoException }
    函数 解决(主机名: 文字, 资源记录类型: "TXT", 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字[][]) => 无值): 无值;

    //@@{ 解决:resolve }
    函数 解决(
        主机名: 文字,
        资源记录类型: 文字,

        //@@{ 错误异常_:ErrnoException, Mx记录_:MxRecord, Naptr记录_:NaptrRecord, Soa记录_:SoaRecord }
        //@@{ Srv记录_:SrvRecord, 任何记录_:AnyRecord }
        回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字[] | Mx记录_[] | Naptr记录_[] | Soa记录_ | Srv记录_[] | 文字[][] | 任何记录_[]) => 无值,
    ): 无值;

    // NOTE: This namespace provides design-time support for util.promisify. Exported members do not exist at runtime.

    //@@{ 解决:resolve }
    名域 解决 {

        //@@{ __转为预设__:__promisify__, 预设_:Promise, "__C名称__":"CNAME" }
        函数 __转为预设__(主机名: 文字, 资源记录类型?: "A" | "AAAA" | "__C名称__" | "NS" | "PTR"): 预设_<文字[]>;

        //@@{ __转为预设__:__promisify__, 预设_:Promise, 任何记录_:AnyRecord }
        函数 __转为预设__(主机名: 文字, 资源记录类型: "ANY"): 预设_<任何记录_[]>;

        //@@{ __转为预设__:__promisify__, 预设_:Promise, Mx记录_:MxRecord }
        函数 __转为预设__(主机名: 文字, 资源记录类型: "MX"): 预设_<Mx记录_[]>;

        //@@{ __转为预设__:__promisify__, 预设_:Promise, Naptr记录_:NaptrRecord }
        函数 __转为预设__(主机名: 文字, 资源记录类型: "NAPTR"): 预设_<Naptr记录_[]>;

        //@@{ __转为预设__:__promisify__, 预设_:Promise, Soa记录_:SoaRecord }
        函数 __转为预设__(主机名: 文字, 资源记录类型: "SOA"): 预设_<Soa记录_>;

        //@@{ __转为预设__:__promisify__, 预设_:Promise, Srv记录_:SrvRecord }
        函数 __转为预设__(主机名: 文字, 资源记录类型: "SRV"): 预设_<Srv记录_[]>;

        //@@{ __转为预设__:__promisify__, 预设_:Promise }
        函数 __转为预设__(主机名: 文字, 资源记录类型: "TXT"): 预设_<文字[][]>;

        //@@{ __转为预设__:__promisify__, 预设_:Promise, Mx记录_:MxRecord, Naptr记录_:NaptrRecord }
        //@@{ Soa记录_:SoaRecord, Srv记录_:SrvRecord, 任何记录_:AnyRecord }
        函数 __转为预设__(主机名: 文字, 资源记录类型: 文字): 预设_<文字[] | Mx记录_[] | Naptr记录_[] | Soa记录_ | Srv记录_[] | 文字[][] | 任何记录_[]>;
    }

    //@@{ 解析4:resolve4, 错误异常_:ErrnoException }
    函数 解析4(主机名: 文字, 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字[]) => 无值): 无值;

    //@@{ 解析4:resolve4, 解析与存活时间选项_:ResolveWithTtlOptions, 错误异常_:ErrnoException }
    //@@{ 记录与存活时间_:RecordWithTtl }
    函数 解析4(主机名: 文字, 选项组: 解析与存活时间选项_, 回调: (错: NodeJS.错误异常_ | 空值, 地址: 记录与存活时间_[]) => 无值): 无值;

    //@@{ 解析4:resolve4, 解析选项_:ResolveOptions, 错误异常_:ErrnoException, 记录与存活时间_:RecordWithTtl }
    函数 解析4(主机名: 文字, 选项组: 解析选项_, 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字[] | 记录与存活时间_[]) => 无值): 无值;

    // NOTE: This namespace provides design-time support for util.promisify. Exported members do not exist at runtime.

    //@@{ 解析4:resolve4 }
    名域 解析4 {

        //@@{ __转为预设__:__promisify__, 预设_:Promise }
        函数 __转为预设__(主机名: 文字): 预设_<文字[]>;

        //@@{ __转为预设__:__promisify__, 解析与存活时间选项_:ResolveWithTtlOptions, 预设_:Promise }
        //@@{ 记录与存活时间_:RecordWithTtl }
        函数 __转为预设__(主机名: 文字, 选项组: 解析与存活时间选项_): 预设_<记录与存活时间_[]>;

        //@@{ __转为预设__:__promisify__, 解析选项_:ResolveOptions, 预设_:Promise, 记录与存活时间_:RecordWithTtl }
        函数 __转为预设__(主机名: 文字, 选项组?: 解析选项_): 预设_<文字[] | 记录与存活时间_[]>;
    }

    //@@{ 解析6:resolve6, 错误异常_:ErrnoException }
    函数 解析6(主机名: 文字, 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字[]) => 无值): 无值;

    //@@{ 解析6:resolve6, 解析与存活时间选项_:ResolveWithTtlOptions, 错误异常_:ErrnoException }
    //@@{ 记录与存活时间_:RecordWithTtl }
    函数 解析6(主机名: 文字, 选项组: 解析与存活时间选项_, 回调: (错: NodeJS.错误异常_ | 空值, 地址: 记录与存活时间_[]) => 无值): 无值;

    //@@{ 解析6:resolve6, 解析选项_:ResolveOptions, 错误异常_:ErrnoException, 记录与存活时间_:RecordWithTtl }
    函数 解析6(主机名: 文字, 选项组: 解析选项_, 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字[] | 记录与存活时间_[]) => 无值): 无值;

    // NOTE: This namespace provides design-time support for util.promisify. Exported members do not exist at runtime.

    //@@{ 解析6:resolve6 }
    名域 解析6 {

        //@@{ __转为预设__:__promisify__, 预设_:Promise }
        函数 __转为预设__(主机名: 文字): 预设_<文字[]>;

        //@@{ __转为预设__:__promisify__, 解析与存活时间选项_:ResolveWithTtlOptions, 预设_:Promise }
        //@@{ 记录与存活时间_:RecordWithTtl }
        函数 __转为预设__(主机名: 文字, 选项组: 解析与存活时间选项_): 预设_<记录与存活时间_[]>;

        //@@{ __转为预设__:__promisify__, 解析选项_:ResolveOptions, 预设_:Promise, 记录与存活时间_:RecordWithTtl }
        函数 __转为预设__(主机名: 文字, 选项组?: 解析选项_): 预设_<文字[] | 记录与存活时间_[]>;
    }

    //@@{ 解析Cname:resolveCname, 错误异常_:ErrnoException }
    函数 解析Cname(主机名: 文字, 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字[]) => 无值): 无值;

    //@@{ 解析Cname:resolveCname }
    名域 解析Cname {

        //@@{ __转为预设__:__promisify__, 预设_:Promise }
        函数 __转为预设__(主机名: 文字): 预设_<文字[]>;
    }

    //@@{ 解析MX:resolveMx, 错误异常_:ErrnoException, Mx记录_:MxRecord }
    函数 解析MX(主机名: 文字, 回调: (错: NodeJS.错误异常_ | 空值, 地址: Mx记录_[]) => 无值): 无值;

    //@@{ 解析MX:resolveMx }
    名域 解析MX {

        //@@{ __转为预设__:__promisify__, 预设_:Promise, Mx记录_:MxRecord }
        函数 __转为预设__(主机名: 文字): 预设_<Mx记录_[]>;
    }

    //@@{ 解析Naptr:resolveNaptr, 错误异常_:ErrnoException, Naptr记录_:NaptrRecord }
    函数 解析Naptr(主机名: 文字, 回调: (错: NodeJS.错误异常_ | 空值, 地址: Naptr记录_[]) => 无值): 无值;

    //@@{ 解析Naptr:resolveNaptr }
    名域 解析Naptr {

        //@@{ __转为预设__:__promisify__, 预设_:Promise, Naptr记录_:NaptrRecord }
        函数 __转为预设__(主机名: 文字): 预设_<Naptr记录_[]>;
    }

    //@@{ 解析NS:resolveNs, 错误异常_:ErrnoException }
    函数 解析NS(主机名: 文字, 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字[]) => 无值): 无值;

    //@@{ 解析NS:resolveNs }
    名域 解析NS {

        //@@{ __转为预设__:__promisify__, 预设_:Promise }
        函数 __转为预设__(主机名: 文字): 预设_<文字[]>;
    }

    //@@{ 解析Ptr:resolvePtr, 错误异常_:ErrnoException }
    函数 解析Ptr(主机名: 文字, 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字[]) => 无值): 无值;

    //@@{ 解析Ptr:resolvePtr }
    名域 解析Ptr {

        //@@{ __转为预设__:__promisify__, 预设_:Promise }
        函数 __转为预设__(主机名: 文字): 预设_<文字[]>;
    }

    //@@{ 解析Soa:resolveSoa, 错误异常_:ErrnoException, Soa记录_:SoaRecord }
    函数 解析Soa(主机名: 文字, 回调: (错: NodeJS.错误异常_ | 空值, 地址: Soa记录_) => 无值): 无值;

    //@@{ 解析Soa:resolveSoa }
    名域 解析Soa {

        //@@{ __转为预设__:__promisify__, 预设_:Promise, Soa记录_:SoaRecord }
        函数 __转为预设__(主机名: 文字): 预设_<Soa记录_>;
    }

    //@@{ 解析Srv:resolveSrv, 错误异常_:ErrnoException, Srv记录_:SrvRecord }
    函数 解析Srv(主机名: 文字, 回调: (错: NodeJS.错误异常_ | 空值, 地址: Srv记录_[]) => 无值): 无值;

    //@@{ 解析Srv:resolveSrv }
    名域 解析Srv {

        //@@{ __转为预设__:__promisify__, 预设_:Promise, Srv记录_:SrvRecord }
        函数 __转为预设__(主机名: 文字): 预设_<Srv记录_[]>;
    }

    //@@{ 解析TxT:resolveTxt, 错误异常_:ErrnoException }
    函数 解析TxT(主机名: 文字, 回调: (错: NodeJS.错误异常_ | 空值, 地址: 文字[][]) => 无值): 无值;

    //@@{ 解析TxT:resolveTxt }
    名域 解析TxT {

        //@@{ __转为预设__:__promisify__, 预设_:Promise }
        函数 __转为预设__(主机名: 文字): 预设_<文字[][]>;
    }

    //@@{ 解决任何:resolveAny, 错误异常_:ErrnoException, 任何记录_:AnyRecord }
    函数 解决任何(主机名: 文字, 回调: (错: NodeJS.错误异常_ | 空值, 地址: 任何记录_[]) => 无值): 无值;

    //@@{ 解决任何:resolveAny }
    名域 解决任何 {

        //@@{ __转为预设__:__promisify__, 预设_:Promise, 任何记录_:AnyRecord }
        函数 __转为预设__(主机名: 文字): 预设_<任何记录_[]>;
    }

    //@@{ 翻转:reverse, 错误异常_:ErrnoException }
    函数 翻转(ip: 文字, 回调: (错: NodeJS.错误异常_ | 空值, 主机名: 文字[]) => 无值): 无值;

    //@@{ 设置服务器:setServers }
    函数 设置服务器(服务器: 文字[]): 无值;

    //@@{ 获取服务器:getServers }
    函数 获取服务器(): 文字[];

    // Error codes

    //@@{ __错误_没有返回数据__:NODATA }
    常量 __错误_没有返回数据__: 文字;

    //@@{ __错误_查询没有格式化__:FORMERR }
    常量 __错误_查询没有格式化__: 文字;

    //@@{ __错误_返回失败__:SERVFAIL }
    常量 __错误_返回失败__: 文字;

    //@@{ __错误_域名没找到__:NOTFOUND }
    常量 __错误_域名没找到__: 文字;

    //@@{ __错误_不执行操作__:NOTIMP }
    常量 __错误_不执行操作__: 文字;

    //@@{ __错误_服务器拒绝__:REFUSED }
    常量 __错误_服务器拒绝__: 文字;

    //@@{ __错误_未格式化查询__:BADQUERY }
    常量 __错误_未格式化查询__: 文字;

    //@@{ __错误_未格式化主机名__:BADNAME }
    常量 __错误_未格式化主机名__: 文字;

    //@@{ __错误_没有提供地址族__:BADFAMILY }
    常量 __错误_没有提供地址族__: 文字;

    //@@{ __错误_未格式化回复__:BADRESP }
    常量 __错误_未格式化回复__: 文字;

    //@@{ __错误_无法连接__:CONNREFUSED }
    常量 __错误_无法连接__: 文字;

    //@@{ __超时__:TIMEOUT }
    常量 __超时__: 文字;

    //@@{ __错误_文件末尾__:EOF }
    常量 __错误_文件末尾__: 文字;

    //@@{ __错误_文件错误__:FILE }
    常量 __错误_文件错误__: 文字;

    //@@{ __错误_内存溢出__:NOMEM }
    常量 __错误_内存溢出__: 文字;

    //@@{ __错误_通道销毁__:DESTRUCTION }
    常量 __错误_通道销毁__: 文字;

    //@@{ __错误_未格式化字符串__:BADSTR }
    常量 __错误_未格式化字符串__: 文字;

    //@@{ __错误_非法标记__:BADFLAGS }
    常量 __错误_非法标记__: 文字;

    //@@{ __错误_没有名字__:NONAME }
    常量 __错误_没有名字__: 文字;

    //@@{ __错误_非法提示标记__:BADHINTS }
    常量 __错误_非法提示标记__: 文字;

    //@@{ __错误_异步请求初始化未完成__:NOTINITIALIZED }
    常量 __错误_异步请求初始化未完成__: 文字;

    //@@{ __错误_加载IP接口错误__:LOADIPHLPAPI }
    常量 __错误_加载IP接口错误__: 文字;

    //@@{ __错误_找不到取网络参数函数错误__:ADDRGETNETWORKPARAMS }
    常量 __错误_找不到取网络参数函数错误__: 文字;

    //@@{ __错误_查询取消__:CANCELLED }
    常量 __错误_查询取消__: 文字;

    //@@{ 解析者_:Resolver }
    类别 解析者_ {

        //@@{ 获取服务器:getServers }
        获取服务器: 类为 获取服务器;

        //@@{ 设置服务器:setServers }
        设置服务器: 类为 设置服务器;

        //@@{ 解决:resolve }
        解决: 类为 解决;

        //@@{ 解析4:resolve4 }
        解析4: 类为 解析4;

        //@@{ 解析6:resolve6 }
        解析6: 类为 解析6;

        //@@{ 解决任何:resolveAny }
        解决任何: 类为 解决任何;

        //@@{ 解析Cname:resolveCname }
        解析Cname: 类为 解析Cname;

        //@@{ 解析MX:resolveMx }
        解析MX: 类为 解析MX;

        //@@{ 解析Naptr:resolveNaptr }
        解析Naptr: 类为 解析Naptr;

        //@@{ 解析NS:resolveNs }
        解析NS: 类为 解析NS;

        //@@{ 解析Ptr:resolvePtr }
        解析Ptr: 类为 解析Ptr;

        //@@{ 解析Soa:resolveSoa }
        解析Soa: 类为 解析Soa;

        //@@{ 解析Srv:resolveSrv }
        解析Srv: 类为 解析Srv;

        //@@{ 解析TxT:resolveTxt }
        解析TxT: 类为 解析TxT;

        //@@{ 翻转:reverse }
        翻转: 类为 翻转;

        //@@{ 取消:cancel }
        取消(): 无值;
    }
}
